webpackJsonp([4],{

    /***/ 0:
    /***/ function(module, exports, __webpack_require__) {

        /* WEBPACK VAR INJECTION */(function($) {'use strict';

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

            var _UIComponentNavbar = __webpack_require__(2);

            var _UIComponentNavbar2 = _interopRequireDefault(_UIComponentNavbar);

            var _HelperPluginJqueryValidate = __webpack_require__(15);

            var _HelperPluginJqueryValidate2 = _interopRequireDefault(_HelperPluginJqueryValidate);

            var _HelperPluginJqueryModal = __webpack_require__(14);

            var _HelperPluginJqueryModal2 = _interopRequireDefault(_HelperPluginJqueryModal);

            var _HelperPluginSlider = __webpack_require__(45);

            var _HelperPluginSlider2 = _interopRequireDefault(_HelperPluginSlider);

            $(document).ready(function () {
                var isMobile = window.matchMedia("only screen and (max-width: 480px)");

                if (isMobile.matches) {
                    var domain = document.domain;
                    var arrUrl = domain.split('jianxun');
                    var repUrl = '//m.jianxun' + arrUrl.pop();
                    $('#s-box1').attr('href', repUrl + "/QA");
                    $('#s-box2').attr('href', repUrl + "/about");
                    $('#s-box3').attr('href', repUrl + "/business/account/application");
                }
            });

            $(document).ready(function () {

                zhuge.track("首页访问");

                // 首页四个注册按钮埋点
                $('.register_btn').click(function () {
                    zhuge.track("点击首页注册按钮");
                });

                $('#invitationcode-apply-form').validate();
                $('.faq-type-list').find('.type-list-item').click(function () {
                    var target = '.' + $(this).data('target') + '-content';
                    $('.faq-collection-container').find('.faq-container-item').css({ 'display': 'none' });
                    $('.faq-collection-container').find(target).css({ 'display': 'block' });
                    $(this).siblings().removeClass('active');
                    $(this).toggleClass('active');
                });

                $('.answer-content').find('li').click(function () {
                    $(this).siblings().removeClass('active');
                    var question = $(this).html().trim();
                    $('.faq .caption-list').siblings('.caption-title').find('span').html(question);
                    $('.faq .caption-list').children().removeClass('active');
                    $('.faq .answer-content li').eq($(this).index()).addClass('active');
                    $('.faq .caption-list li').eq($(this).index()).addClass('active');
                });

                // $('.events-lists-content').unslider({
                //   speed: 500,               //  The speed to animate each slide (in milliseconds)
                //   delay: 30000,              //  The delay between slide animations (in milliseconds)
                //   complete: function() {},  //  A function that gets called after every slide animation
                //   keys: true,               //  Enable keyboard (left, right) arrow shortcuts
                //   dots: true,               //  Display dot navigation
                //   arrows: true,
                //   fluid: false              //  Support responsive design. May break non-responsive designs
                // });

                $('.video-trigger .dark').click(function () {
                    $('.jianxun-video-modal').openModal({
                        stretch: true
                    });
                    // $('#lean-overlay').remove();
                    // $('#jianxun-video').css({'display': 'block'});
                });

                $('body').delegate('#lean-overlay', 'click', function () {
                    // console.log('jiale');
                    var jianxunVideo = document.getElementById('jianxun-video');
                    jianxunVideo.pause();
                });

                $('.question-list').on('click', 'li', function () {
                    $('.question-list li, .answer-list li').removeClass('active');
                    $(this).addClass('active');
                    $('.question-title span').html($(this).html());
                    $('.answer-list li[data-index="' + $(this).attr('data-index') + '"]').addClass('active');
                    var index = $(this).data('index');
                    $('.answer[data-index=' + index + ']').addClass('active');
                });

                $(window).scroll(function () {
                    var offset = $(window).scrollTop();
                    // // if(offset < 64 ) {
                    // //   $('.navbar').css({
                    // //     'position':'fixed',
                    // //     'top': '0'
                    // //   });
                    // // }
                    // if (offset < 500) {
                    //   $('.page-banner .bg img').css('transform', 'translate3d(0px, ' + offset / 3 + 'px, 0px)');
                    //   $('.iphone').css('transform', 'translate3d(0px, ' + offset / 9 + 'px, 0px)');
                    //   $('.ipad').css('transform', 'translate3d(0px, ' + offset / 6 + 'px, 0px)');
                    // }

                    throttle(function () {
                        if (offset > 60) {
                            $('nav').addClass('white');
                        } else {
                            $('nav').removeClass('white');
                        }
                    }, 100, 300)();
                });

                //带间隔执行的节流函数
                function throttle(method, delay, duration) {
                    var timer = null;
                    var begin = new Date();
                    return function () {
                        var context = this,
                            args = arguments,
                            current = new Date();;
                        clearTimeout(timer);
                        if (current - begin >= duration) {
                            method.apply(context, args);
                            begin = current;
                        } else {
                            timer = setTimeout(function () {
                                method.apply(context, args);
                            }, delay);
                        }
                    };
                }

                // sliders 轮播
                var unslider = $('.evaluations.sliders').unslider({
                    speed: 300,
                    delay: false,
                    init: 0,
                    keys: true,
                    arrows: true,
                    prev: '&#xe600;',
                    next: '&#xe60c;',
                    fluid: true
                });
            });
            // autoplay: true  // 自动播放
            /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

        /***/ },

    /***/ 14:
    /***/ function(module, exports, __webpack_require__) {

        var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';

        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(1), __webpack_require__(8)], __WEBPACK_AMD_DEFINE_RESULT__ = function ($, velocity) {

            $.fn.velocity = velocity;

            $.fn.extend({
                openModal: function openModal(options) {
                    var modal = this;
                    var overlay = $('<div id="lean-overlay"></div>');
                    $("body").append(overlay);
                    var defaults = {
                        opacity: 0.5,
                        in_duration: 350,
                        out_duration: 250,
                        ready: undefined,
                        complete: undefined,
                        dismissible: true,
                        // whether the modal stretch to through the bottom, default false;
                        stretch: false
                    };

                    // Override defaults
                    options = $.extend(defaults, options);
                    if (options.dismissible) {
                        $("#lean-overlay").click(function () {
                            $(modal).closeModal(options);
                        });
                        // Return on ESC
                        $(document).on('keyup.leanModal', function (e) {
                            if (e.keyCode === 27) {
                                // ESC key
                                $(modal).closeModal(options);
                            }
                        });
                    }

                    $(modal).find(".modal-close").click(function (e) {
                        $(modal).closeModal(options);
                    });

                    $("#lean-overlay").css({ display: "block", opacity: 0 });

                    $(modal).css({
                        display: "block",
                        opacity: 0
                    });

                    $("#lean-overlay").velocity({ opacity: options.opacity }, { duration: options.in_duration, queue: false, ease: "easeOutCubic" });

                    // Define Bottom Sheet animation
                    if ($(modal).hasClass('bottom-sheet')) {
                        $(modal).velocity({ bottom: "0", opacity: 1 }, {
                            duration: options.in_duration,
                            queue: false,
                            ease: "easeOutCubic",
                            // Handle modal ready callback
                            complete: function complete() {
                                if (typeof options.ready === "function") {
                                    options.ready();
                                }
                            }
                        });
                    } else {
                        $(modal).css({ top: "4%" });
                        // console.log($(window).outerHeight());
                        var windowHeight = $(window).outerHeight();
                        var modalHeight = $(modal).outerHeight();
                        var style = {
                            top: '10%',
                            opacity: 1
                        };

                        if (!options.stretch && windowHeight - modalHeight < 0.2 * windowHeight) {
                            style['bottom'] = '10%';
                        }

                        $(modal).velocity(style, {
                            duration: options.in_duration,
                            queue: false,
                            ease: "easeOutCubic",
                            // Handle modal ready callback
                            complete: function complete() {
                                if (typeof options.ready === "function") {
                                    options.ready();
                                }
                            }
                        });
                    }
                }
            });

            $.fn.extend({
                closeModal: function closeModal(options) {
                    var defaults = {
                        out_duration: 250,
                        complete: undefined
                    };
                    var options = $.extend(defaults, options);

                    $('.modal-close').off();
                    $(document).off('keyup.leanModal');

                    $("#lean-overlay").velocity({ opacity: 0 }, { duration: options.out_duration, queue: false, ease: "easeOutQuart" });

                    // Define Bottom Sheet animation
                    if ($(this).hasClass('bottom-sheet')) {
                        $(this).velocity({ bottom: "-100%", opacity: 0 }, {
                            duration: options.out_duration,
                            queue: false,
                            ease: "easeOutCubic",
                            // Handle modal ready callback
                            complete: function complete() {
                                $("#lean-overlay").css({ display: "none" });

                                // Call complete callback
                                if (typeof options.complete === "function") {
                                    options.complete();
                                }
                                $('#lean-overlay').remove();
                            }
                        });
                    } else {
                        $(this).fadeOut(options.out_duration, function () {
                            $(this).css({ top: 0 });
                            $("#lean-overlay").css({ display: "none" });

                            // Call complete callback
                            if (typeof options.complete === "function") {
                                options.complete();
                            }
                            $('#lean-overlay').remove();
                        });
                    }
                }
            });

            $.fn.extend({
                // 如果不需要一个modal的trigger而是直接启动,不需要初始化直接openModal就可以了
                leanModal: function leanModal(options) {
                    return this.each(function () {
                        // Close Handlers
                        $(this).click(function (e) {
                            var modal_id = $(this).attr("href") || '#' + $(this).data('target');
                            if (!!modal_id) {
                                $(modal_id).openModal(options);
                            }
                            e.preventDefault();
                        }); // done set on click
                    }); // done return
                }
            });
        }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

        /***/ },

    /***/ 15:
    /***/ function(module, exports, __webpack_require__) {

        var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';

        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(1), __webpack_require__(16)], __WEBPACK_AMD_DEFINE_RESULT__ = function ($) {

            $.fn.extend({
                validate: function validate(callback) {

                    // Checks if instance is already created
                    if (this.data("instance")) {
                        return;
                    }

                    var $this = this;
                    var temp = [];
                    $this.find(".validate").each(function (i, el) {
                        var $el = $(el);
                        /* $el.keyup(function(){
                         console.log($el.val());
                         }) */
                        temp.push({
                            name: $el.attr("name"),
                            rules: $el.attr("data-rules"),
                            display: $el.attr("data-display")
                        });
                    });
                    // console.log(temp);
                    // Create FormValidator object
                    var validator = new FormValidator($this.attr('id'), temp, function (errors, event) {
                        // Clear all error fields
                        $this.find(".error").removeClass("error");
                        $this.find(".help-block").attr('data-error', errors);
                        // Check for errors
                        if (errors.length > 0) {
                            $.each(errors, function (index, err) {
                                // Displays the erros message in the help-block
                                var $target = $this.find("*[id='" + err.id + "']").next(".help-block").html(err.message);
                                // Adds error class to the controlgroup (bootstrap)
                                $target.closest(".control-group").removeClass("error").addClass("error");
                            });
                            return false;
                        } else {
                            if (typeof callback === "function") {
                                callback($this, event); //execute callback on form success
                            }
                        }
                    });
                    this.data("instance", validator);
                }

            });
        }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

        /***/ },

    /***/ 16:
    /***/ function(module, exports, __webpack_require__) {

        var __WEBPACK_AMD_DEFINE_RESULT__;// 动态检测：
        // 给每个确定的区域进行实时正则检测，及时报错
        'use strict';

        !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
            var defaults = {
                messages: {
                    required: '%s 不能为空.',
                    matches: '%s 和 %s 不一致.',
                    valid_email: '%s 必须是一个正确格式的邮箱地址',
                    valid_company_email: '请输入公司内部邮箱，暂不支持公共邮箱',
                    valid_telephone: '请输入正确的手机号.',
                    valid_name: '只能包含字母，数字和下划线.',
                    valid_university: '请输入正确的学校名称.',
                    valid_password: '密码必须包含数字和字母',
                    valid_website: '网址格式错误',
                    min_length: '%s 长度至少需要 %s 位',
                    max_length: '%s 长度不能超过 %s 位.',
                    exact_length: '%s 长度只能是 %s 位',
                    less_than: 'The %s field must contain a number less than %s.',
                    alpha: 'The %s field must only contain alphabetical characters.',
                    alpha_numeric: '%s 只能包含数字',
                    alpha_dash: 'The %s field must only contain alpha-numeric characters, underscores, and dashes.',
                    numeric: 'The %s field must contain only numbers.',
                    integer: '%s 只能是整数.',
                    decimal: 'The %s field must contain a decimal number.',
                    is_natural: 'The %s field must contain only positive numbers.',
                    is_natural_no_zero: 'The %s field must contain a number greater than zero.',
                    valid_ip: 'The %s field must contain a valid IP.',
                    valid_base64: 'The %s field must contain a base64 string.',
                    valid_credit_card: 'The %s field must contain a valid credit card number.',
                    is_file_type: 'The %s field must contain only %s files.',
                    valid_url: 'The %s field must contain a valid URL.',
                    greater_than_date: 'The %s field must contain a more recent date than %s.',
                    less_than_date: 'The %s field must contain an older date than %s.',
                    greater_than_or_equal_date: 'The %s field must contain a date that\'s at least as recent as %s.',
                    less_than_or_equal_date: 'The %s field must contain a date that\'s %s or older.'
                },
                callback: function callback(errors) {}
            };

            /*
             * Define the regular expressions that will be used
             */

            // 检测是否为正常的条件，比较奇葩的是min_length[12], matches[password]
            var ruleRegex = /^(.+?)\[(.+)\]$/,
                numericRegex = /^[0-9]+$/,
                integerRegex = /^\-?[0-9]+$/,
                decimalRegex = /^\-?[0-9]*\.?[0-9]+$/,

                // emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,
                emailRegex = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i,
                companyEmailRegex = /@(qq|163|126|yeah|sina|sohu189|yahoo|gmail|139|188|hotmail|yahoo\.com|tom|msn|eyou|sogou|263|21cn|googlemail|outlook)\.(com|cn|net)$/i,
                telephoneRegex = /^13[0-9]{9}$|14[0-9]{9}$|15[0-9]{9}$|17[0-9]{9}$|18[0-9]{9}$/,
                passwordRegex = /^(?![a-zA-z]+$)(?!\d+$)/i,
                websiteRegex = /^((https|http|ftp|rtsp|mms):\/\/){1}/,

                // nameRegex = /^[a-zA-Z0-9_\-]+$/i,
                nameRegex = /^[\u4e00-\u9fa5]{1,8}$|^[\dA-Za-z_]{1,20}$/,
                universityRegex = /^[\u4e00-\u9fa5]{0,30}$|^[\dA-Za-z]{1,20}$/,

                // 匹配中文长度不超过8位或者20个字节
                alphaRegex = /^[a-z]+$/i,
                alphaNumericRegex = /^[a-z0-9]+$/i,
                alphaDashRegex = /^[a-z0-9_\-]+$/i,
                naturalRegex = /^[0-9]+$/i,
                naturalNoZeroRegex = /^[1-9][0-9]*$/i,
                ipRegex = /^((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\.){3}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})$/i,
                base64Regex = /[^a-zA-Z0-9\/\+=]/i,
                numericDashRegex = /^[\d\-\s]+$/,
                urlRegex = /^((http|https):\/\/(\w+:{0,1}\w*@)?(\S+)|)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/,
                dateRegex = /\d{4}-\d{1,2}-\d{1,2}/;
            /*
             * The exposed public object to validate a form:
             *
             * @param formNameOrNode - String - The name attribute of the form (i.e. <form name="myForm"></form>) or node of the form element
             * @param fields - Array - [{
             *     name: The name of the element (i.e. <input name="myField" />)
             *     display: 'Field Name'
             *     rules: required|matches[password_confirm]
             * }]
             * @param callback - Function - The callback after validation has been performed.
             *     @argument errors - An array of validation errors
             *     @argument event - The javascript event
             */

            var FormValidator = function FormValidator(formNameOrNode, fields, callback) {

                    this.callback = callback || defaults.callback;
                    this.errors = [];
                    this.fields = {};
                    this.form = this._formByNameOrNode(formNameOrNode) || {};
                    this.messages = {};
                    this.handlers = {};
                    this.conditionals = {};

                    for (var i = 0, fieldLength = fields.length; i < fieldLength; i++) {
                        var field = fields[i];
                        // If passed in incorrectly, we need to skip the field.
                        if (!field.name && !field.names || !field.rules) {
                            continue;
                        }

                        /*
                         * Build the master fields array that has all the information needed to validate
                         */
                        var element = this.form[field.name],
                            that = this;
                        // console.log(element);
                        if (element && element !== undefined) {
                            field.id = attributeValue(element, 'id');
                            field.element = element;
                            field.type = element.length > 0 ? element[0].type : element.type;
                            field.checked = attributeValue(element, 'checked');
                            field.element.onkeyup = (function (e) {
                                // console.log(e.keyCode);
                                this.value = attributeValue(this.element, 'value');
                                // this.element.nextElementSibling.dataset.error = that._validateField(this);
                                // 实时显示错误
                                /* console.log(this.value); */
                                // this.element.parentNode.lastChild.previousSibling.innerHTML = that._validateField(this);
                            }).bind(field);
                            // console.log('jiale');

                            field.element.onblur = (function (e) {
                                // console.log('blur');
                                this.value = attributeValue(this.element, 'value');
                                /* console.log('jiale');
                                 console.log(this.value); */
                                this.element.parentNode.lastChild.previousSibling.innerHTML = that._validateField(this);
                            }).bind(field);
                            field.element.onfocus = (function (e) {
                                // console.log('focus');
                                // $(this.element).closest('.input-field').find('.help-block').html('');
                                this.element.parentNode.lastChild.previousSibling.innerHTML = '';
                            }).bind(field);

                            this._addField(field, field.name);
                        }
                    }
                    // attach an event callback when user input

                    /*
                     * Attach an event callback for the form submission
                     */

                    var _onsubmit = this.form.onsubmit;

                    this.form.onsubmit = (function (that) {
                        return function (evt) {
                            try {
                                return that._validateForm(evt) && (_onsubmit === undefined || _onsubmit());
                            } catch (e) {}
                        };
                    })(this);
                },
                attributeValue = function attributeValue(element, attributeName) {
                    var i;

                    if (element.length > 0 && (element[0].type === 'radio' || element[0].type === 'checkbox')) {
                        for (i = 0, elementLength = element.length; i < elementLength; i++) {
                            if (element[i].checked) {
                                return element[i][attributeName];
                            }
                        }
                        return;
                    }

                    return element[attributeName];
                };

            /*
             * @public
             * Sets a custom message for one of the rules
             */

            FormValidator.prototype.setMessage = function (rule, message) {
                this.messages[rule] = message;

                // return this for chaining
                return this;
            };

            /*
             * @public
             * Registers a callback for a custom rule (i.e. callback_username_check)
             */

            FormValidator.prototype.registerCallback = function (name, handler) {
                if (name && typeof name === 'string' && handler && typeof handler === 'function') {
                    this.handlers[name] = handler;
                }

                // return this for chaining
                return this;
            };

            /*
             * @public
             * Registers a conditional for a custom 'depends' rule
             */

            FormValidator.prototype.registerConditional = function (name, conditional) {
                if (name && typeof name === 'string' && conditional && typeof conditional === 'function') {
                    this.conditionals[name] = conditional;
                }

                // return this for chaining
                return this;
            };

            /*
             * @private
             * Determines if a form dom node was passed in or just a string representing the form name
             */

            FormValidator.prototype._formByNameOrNode = function (formNameOrNode) {
                return typeof formNameOrNode === 'object' ? formNameOrNode : document.forms[formNameOrNode];
            };

            /*
             * @private
             * Adds a file to the master fields array
             */

            FormValidator.prototype._addField = function (field, nameValue) {
                this.fields[nameValue] = {
                    name: nameValue,
                    display: field.display || nameValue,
                    rules: field.rules,
                    depends: field.depends,
                    id: null,
                    element: null,
                    type: null,
                    value: null,
                    checked: null
                };
            };

            /*
             * @private
             * Runs the validation when the form is submitted.
             */

            FormValidator.prototype._validateForm = function (evt) {
                this.errors = [];

                for (var key in this.fields) {
                    if (this.fields.hasOwnProperty(key)) {
                        var field = this.fields[key] || {},
                            element = this.form[field.name];

                        if (element && element !== undefined) {
                            field.id = attributeValue(element, 'id');
                            field.element = element;
                            field.type = element.length > 0 ? element[0].type : element.type;
                            field.value = attributeValue(element, 'value');
                            field.checked = attributeValue(element, 'checked');

                            /*
                             * Run through the rules for each field.
                             * If the field has a depends conditional, only validate the field
                             * if it passes the custom function
                             */

                            if (field.depends && typeof field.depends === "function") {
                                if (field.depends.call(this, field)) {
                                    this._validateField(field);
                                }
                            } else if (field.depends && typeof field.depends === "string" && this.conditionals[field.depends]) {
                                if (this.conditionals[field.depends].call(this, field)) {
                                    this._validateField(field);
                                }
                            } else {
                                this._validateField(field);
                            }
                        }
                    }
                }

                if (typeof this.callback === 'function') {
                    this.callback(this.errors, evt);
                }

                if (this.errors.length > 0) {
                    if (evt && evt.preventDefault) {
                        evt.preventDefault();
                    } else if (event) {
                        // IE uses the global event variable
                        event.returnValue = false;
                    }
                }

                return true;
            };

            /*
             * @private
             * Looks at the fields value and evaluates it against the given rules
             */

            FormValidator.prototype._validateField = function (field) {
                var rules = field.rules.split('|'),
                    indexOfRequired = field.rules.indexOf('required'),
                    isEmpty = !field.value || field.value === '' || field.value === undefined;
                /*
                 * Run through the rules and execute the validation methods as needed
                 */

                for (var i = 0, ruleLength = rules.length; i < ruleLength; i++) {
                    var method = rules[i],
                        param = null,
                        failed = false,

                        // 检测是否是空
                        parts = ruleRegex.exec(method);
                    /*
                     * If this field is not required and the value is empty, continue on to the next rule unless it's a callback.
                     * This ensures that a callback will always be called but other rules will be skipped.
                     */

                    if (indexOfRequired === -1 && method.indexOf('!callback_') === -1 && isEmpty) {
                        continue;
                    }

                    /*
                     * If the rule has a parameter (i.e. matches[param]) split it out
                     * 或者是 min_length[10]
                     */
                    // ["jiale[12]", "jiale", "12"]
                    // 其中第一个匹配的是全部，第二个参数也就是method,第三个是param
                    if (parts) {
                        method = parts[1];
                        param = parts[2];
                    }

                    if (method.charAt(0) === '!') {
                        method = method.substring(1, method.length);
                    }

                    /*
                     * If the hook is defined, run it to find any validation errors
                     */
                    // hook是一堆定义好的检测相应正则匹配的函数
                    if (typeof this._hooks[method] === 'function') {
                        if (!this._hooks[method].apply(this, [field, param])) {
                            failed = true;
                        }
                    } else if (method.substring(0, 9) === 'callback_') {
                        // Custom method. Execute the handler if it was registered
                        // 自定义的检测函数
                        method = method.substring(9, method.length);

                        if (typeof this.handlers[method] === 'function') {
                            if (this.handlers[method].apply(this, [field.value, param, field]) === false) {
                                failed = true;
                            }
                        }
                    }

                    /*
                     * If the hook failed, add a message to the errors array
                     */

                    if (failed) {
                        // Make sure we have a message for this rule
                        var source = this.messages[field.name + '.' + method] || this.messages[method] || defaults.messages[method],
                            message = 'An error has occurred with the ' + field.display + ' field.';

                        if (source) {
                            message = source.replace('%s', field.display);

                            if (param) {
                                message = message.replace('%s', this.fields[param] ? this.fields[param].display : param);
                            }
                        }
                        this.errors.push({
                            id: field.id,
                            element: field.element,
                            name: field.name,
                            message: message,
                            rule: method
                        });

                        // Break out so as to not spam with validation errors (i.e. required and valid_email)
                        break;
                    }
                }
                return message ? message : '';
            };

            /**
             * private function _getValidDate: helper function to convert a string date to a Date object
             * @param date (String) must be in format yyyy-mm-dd or use keyword: today
             * @returns {Date} returns false if invalid
             */
            FormValidator.prototype._getValidDate = function (date) {
                if (!date.match('today') && !date.match(dateRegex)) {
                    return false;
                }

                var validDate = new Date(),
                    validDateArray;

                if (!date.match('today')) {
                    validDateArray = date.split('-');
                    validDate.setFullYear(validDateArray[0]);
                    validDate.setMonth(validDateArray[1] - 1);
                    validDate.setDate(validDateArray[2]);
                }
                return validDate;
            };

            /*
             * @private
             * Object containing all of the validation hooks
             */

            FormValidator.prototype._hooks = {
                required: function required(field) {
                    var value = field.value;

                    if (field.type === 'checkbox' || field.type === 'radio') {
                        return field.checked === true;
                    }

                    return value !== null && value !== '';
                },

                "default": function _default(field, defaultName) {
                    return field.value !== defaultName;
                },

                matches: function matches(field, matchName) {
                    var el = this.form[matchName];

                    if (el) {
                        return field.value === el.value;
                    }

                    return false;
                },

                valid_email: function valid_email(field) {
                    return emailRegex.test(field.value);
                },
                valid_company_email: function valid_company_email(field) {
                    return !companyEmailRegex.test(field.value);
                },
                valid_password: function valid_password(field) {
                    return passwordRegex.test(field.value);
                },
                valid_website: function valid_website(field) {
                    return websiteRegex.test(field.value);
                },
                // 自定义的姓名格式检测
                valid_name: function valid_name(field) {
                    return nameRegex.test(field.value);
                },

                valid_university: function valid_university(field) {
                    return universityRegex.test(field.value);
                },

                valid_telephone: function valid_telephone(field) {
                    return telephoneRegex.test(field.value);
                },

                valid_emails: function valid_emails(field) {
                    var result = field.value.split(/\s*,\s*/g);

                    for (var i = 0, resultLength = result.length; i < resultLength; i++) {
                        if (!emailRegex.test(result[i])) {
                            return false;
                        }
                    }

                    return true;
                },

                min_length: function min_length(field, length) {
                    if (!numericRegex.test(length)) {
                        return false;
                    }

                    return field.value.length >= parseInt(length, 10);
                },

                max_length: function max_length(field, length) {
                    if (!numericRegex.test(length)) {
                        return false;
                    }

                    return field.value.length <= parseInt(length, 10);
                },

                exact_length: function exact_length(field, length) {
                    if (!numericRegex.test(length)) {
                        return false;
                    }

                    return field.value.length === parseInt(length, 10);
                },

                greater_than: function greater_than(field, param) {
                    if (!decimalRegex.test(field.value)) {
                        return false;
                    }

                    return parseFloat(field.value) > parseFloat(param);
                },

                less_than: function less_than(field, param) {
                    if (!decimalRegex.test(field.value)) {
                        return false;
                    }

                    return parseFloat(field.value) < parseFloat(param);
                },

                alpha: function alpha(field) {
                    return alphaRegex.test(field.value);
                },

                alpha_numeric: function alpha_numeric(field) {
                    return alphaNumericRegex.test(field.value);
                },

                alpha_dash: function alpha_dash(field) {
                    return alphaDashRegex.test(field.value);
                },

                numeric: function numeric(field) {
                    return numericRegex.test(field.value);
                },

                integer: function integer(field) {
                    return integerRegex.test(field.value);
                },

                decimal: function decimal(field) {
                    return decimalRegex.test(field.value);
                },

                is_natural: function is_natural(field) {
                    return naturalRegex.test(field.value);
                },

                is_natural_no_zero: function is_natural_no_zero(field) {
                    return naturalNoZeroRegex.test(field.value);
                },

                valid_ip: function valid_ip(field) {
                    return ipRegex.test(field.value);
                },

                valid_base64: function valid_base64(field) {
                    return base64Regex.test(field.value);
                },

                valid_url: function valid_url(field) {
                    return urlRegex.test(field.value);
                },

                valid_credit_card: function valid_credit_card(field) {
                    // Luhn Check Code from https://gist.github.com/4075533
                    // accept only digits, dashes or spaces
                    if (!numericDashRegex.test(field.value)) return false;

                    // The Luhn Algorithm. It's so pretty.
                    var nCheck = 0,
                        nDigit = 0,
                        bEven = false;
                    var strippedField = field.value.replace(/\D/g, "");

                    for (var n = strippedField.length - 1; n >= 0; n--) {
                        var cDigit = strippedField.charAt(n);
                        nDigit = parseInt(cDigit, 10);
                        if (bEven) {
                            if ((nDigit *= 2) > 9) nDigit -= 9;
                        }

                        nCheck += nDigit;
                        bEven = !bEven;
                    }

                    return nCheck % 10 === 0;
                },

                is_file_type: function is_file_type(field, type) {
                    if (field.type !== 'file') {
                        return true;
                    }

                    var ext = field.value.substr(field.value.lastIndexOf('.') + 1),
                        typeArray = type.split(','),
                        inArray = false,
                        i = 0,
                        len = typeArray.length;

                    for (i; i < len; i++) {
                        if (ext == typeArray[i]) inArray = true;
                    }

                    return inArray;
                },

                greater_than_date: function greater_than_date(field, date) {
                    var enteredDate = this._getValidDate(field.value),
                        validDate = this._getValidDate(date);

                    if (!validDate || !enteredDate) {
                        return false;
                    }

                    return enteredDate > validDate;
                },

                less_than_date: function less_than_date(field, date) {
                    var enteredDate = this._getValidDate(field.value),
                        validDate = this._getValidDate(date);

                    if (!validDate || !enteredDate) {
                        return false;
                    }

                    return enteredDate < validDate;
                },

                greater_than_or_equal_date: function greater_than_or_equal_date(field, date) {
                    var enteredDate = this._getValidDate(field.value),
                        validDate = this._getValidDate(date);

                    if (!validDate || !enteredDate) {
                        return false;
                    }

                    return enteredDate >= validDate;
                },

                less_than_or_equal_date: function less_than_or_equal_date(field, date) {
                    var enteredDate = this._getValidDate(field.value),
                        validDate = this._getValidDate(date);

                    if (!validDate || !enteredDate) {
                        return false;
                    }

                    return enteredDate <= validDate;
                }
            };

            window.FormValidator = FormValidator;
        }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

        /***/ },

    /***/ 45:
    /***/ function(module, exports, __webpack_require__) {

        /* WEBPACK VAR INJECTION */(function($) {'use strict';

            var Unslider = function Unslider() {
                //  Object clone
                var _ = this,
                    f = false;

                //  Set some options
                _.o = {
                    speed: 500, // animation speed, false for no transition (integer or boolean)
                    delay: 3000, // delay between slides, false for no autoplay (integer or boolean)
                    init: 0, // init delay, false for no delay (integer or boolean)
                    pause: !f, // pause on hover (boolean)
                    loop: !f, // infinitely looping (boolean)
                    keys: f, // keyboard shortcuts (boolean)
                    dots: f, // display dots pagination (boolean)
                    arrows: f, // display prev/next arrows (boolean)
                    prev: '&larr;', // text or html inside prev button (string)
                    next: '&rarr;', // same as for prev option
                    fluid: f, // is it a percentage width? (boolean)
                    starting: f, // invoke before animation (function with argument)
                    complete: f, // invoke after animation (function with argument)
                    items: '>ul', // slides container selector
                    item: '>li', // slidable items selector
                    easing: 'swing', // easing function to use for animation
                    autoplay: true // enable autoplay on initialisation
                };

                _.init = function (el, o) {
                    //  Check whether we're passing any options in to Unslider
                    _.o = $.extend(_.o, o);

                    _.el = el;
                    _.ul = el.find(_.o.items);
                    _.max = [el.outerWidth() | 0, el.outerHeight() | 0];
                    _.li = _.ul.find(_.o.item).each(function (index) {
                        var me = $(this),
                            width = me.outerWidth(),
                            height = me.outerHeight();

                        //  Set the max values
                        if (width > _.max[0]) _.max[0] = width;
                        if (height > _.max[1]) _.max[1] = height;
                    });

                    //  Cached vars
                    var o = _.o,
                        ul = _.ul,
                        li = _.li,
                        len = li.length;

                    //  Current indeed
                    _.i = 0;

                    //  Set the main element
                    el.css({ width: _.max[0], height: li.first().outerHeight(), overflow: 'hidden' });

                    //  Set the relative widths
                    ul.css({ position: 'relative', left: 0, width: len * 100 + '%' });
                    /* console.log(o.fluid) */
                    if (o.fluid) {
                        li.css({ 'float': 'left', width: 100 / len + '%' });
                    } else {
                        li.css({ 'float': 'left', width: _.max[0] + 'px' });
                    }

                    //  Autoslide
                    o.autoplay && setTimeout(function () {
                        if (o.delay | 0) {
                            _.play();

                            if (o.pause) {
                                el.on('mouseover mouseout', function (e) {
                                    _.stop();
                                    e.type === 'mouseout' && _.play();
                                });
                            };
                        };
                    }, o.init | 0);

                    //  Keypresses
                    if (o.keys) {
                        $(document).keydown(function (e) {
                            switch (e.which) {
                                case 37:
                                    _.prev(); // Left
                                    break;
                                case 39:
                                    _.next(); // Right
                                    break;
                                case 27:
                                    _.stop(); // Esc
                                    break;
                            };
                        });
                    };

                    //  Dot pagination
                    o.dots && nav('dot');

                    //  Arrows support
                    o.arrows && nav('arrow');

                    //  Patch for fluid-width sliders. Screw those guys.
                    o.fluid && $(window).resize(function () {
                        _.r && clearTimeout(_.r);

                        _.r = setTimeout(function () {
                            var styl = { height: li.eq(_.i).outerHeight() },
                                width = el.outerWidth();

                            ul.css(styl);
                            styl['width'] = Math.min(Math.round(width / el.parent().width() * 100), 100) + '%';
                            el.css(styl);
                            li.css({ width: width + 'px' });
                        }, 50);
                    }).resize();

                    //  Move support
                    if ($.event.special['move'] || $.Event('move')) {
                        el.on('movestart', function (e) {
                            if (e.distX > e.distY && e.distX < -e.distY || e.distX < e.distY && e.distX > -e.distY) {
                                e.preventDefault();
                            } else {
                                el.data("left", _.ul.offset().left / el.width() * 100);
                            }
                        }).on('move', function (e) {
                            var left = 100 * e.distX / el.width();
                            var leftDelta = 100 * e.deltaX / el.width();
                            _.ul[0].style.left = parseInt(_.ul[0].style.left.replace("%", "")) + leftDelta + "%";

                            _.ul.data("left", left);
                        }).on('moveend', function (e) {
                            var left = _.ul.data("left");
                            if (Math.abs(left) > 30) {
                                var i = left > 0 ? _.i - 1 : _.i + 1;
                                if (i < 0 || i >= len) i = _.i;
                                _.to(i);
                            } else {
                                _.to(_.i);
                            }
                        });
                    };

                    return _;
                };

                //  Move Unslider to a slide index
                _.to = function (index, callback) {
                    if (_.t) {
                        _.stop();
                        _.play();
                    }
                    var o = _.o,
                        el = _.el,
                        ul = _.ul,
                        li = _.li,
                        current = _.i,
                        target = li.eq(index);

                    $.isFunction(o.starting) && !callback && o.starting(el, li.eq(current));

                    //  To slide or not to slide
                    if ((!target.length || index < 0) && o.loop === f) return;

                    //  Check if it's out of bounds
                    if (!target.length) index = 0;
                    if (index < 0) index = li.length - 1;
                    target = li.eq(index);

                    var speed = callback ? 5 : o.speed | 0,
                        easing = o.easing,
                        obj = { height: target.outerHeight() };

                    if (!ul.queue('fx').length) {
                        //  Handle those pesky dots
                        el.find('.dot').eq(index).addClass('active').siblings().removeClass('active');

                        el.animate(obj, speed, easing) && ul.animate($.extend({ left: '-' + index + '00%' }, obj), speed, easing, function (data) {
                            _.i = index;

                            $.isFunction(o.complete) && !callback && o.complete(el, target);
                        });
                    };
                };

                //  Autoplay functionality
                _.play = function () {
                    _.t = setInterval(function () {
                        _.to(_.i + 1);
                    }, _.o.delay | 0);
                };

                //  Stop autoplay
                _.stop = function () {
                    _.t = clearInterval(_.t);
                    return _;
                };

                //  Move to previous/next slide
                _.next = function () {
                    return _.stop().to(_.i + 1);
                };

                _.prev = function () {
                    return _.stop().to(_.i - 1);
                };

                //  Create dots and arrows
                function nav(name, html) {
                    if (name == 'dot') {
                        html = '<ol class="dots">';
                        $.each(_.li, function (index) {
                            html += '<li class="' + (index === _.i ? name + ' active' : name) + '">' + ++index + '</li>';
                        });
                        html += '</ol>';
                    } else {
                        html = '<div class="';
                        html = html + name + 's">' + html + name + ' prev">' + _.o.prev + '</div>' + html + name + ' next">' + _.o.next + '</div></div>';
                    };

                    _.el.addClass('has-' + name + 's').append(html).find('.' + name).click(function () {
                        var me = $(this);
                        me.hasClass('dot') ? _.stop().to(me.index()) : me.hasClass('prev') ? _.prev() : _.next();
                    });
                };
            };

            //  Create a jQuery plugin
            $.fn.unslider = function (o) {
                var len = this.length;
                //  Enable multiple-slider support
                return this.each(function (index) {
                    //  Cache a copy of $(this), so it
                    var me = $(this),
                        key = 'unslider' + (len > 1 ? '-' + ++index : ''),
                        instance = new Unslider().init(me, o);

                    //  Invoke an Unslider instance
                    me.data(key, instance).data('key', key);
                });
            };
            /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

        /***/ }

});